home *** CD-ROM | disk | FTP | other *** search
/ Aminet 6 / Aminet 6 - June 1995.iso / Aminet / gfx / 3d / irit50src.lha / irit5 / prsr_lib / trivread.c < prev   
Encoding:
C/C++ Source or Header  |  1995-02-14  |  20.9 KB  |  545 lines
  1. /******************************************************************************
  2. * TrivRead.c - Tri-variate(s) reading from files.                  *
  3. *******************************************************************************
  4. * Written by Gershon Elber, Sep. 94.                          *
  5. ******************************************************************************/
  6.  
  7. #include "prsr_loc.h"
  8. #include "ctype.h"
  9.  
  10. /*****************************************************************************
  11. * DESCRIPTION:                                                               M
  12. * Reads from a file trivariates.                         M
  13. *   If error is detected in reading the file, ErrStr is set to a string      M
  14. * describing the error and Line to the line it occured in file.             M
  15. *   If no error is detected *ErrStr = NULL.                     M
  16. *                                                                            *
  17. * PARAMETERS:                                                                M
  18. *   FileName:     To read the trivariate from.                              M
  19. *   ErrStr:       Will be initialized if an error has occured.               M
  20. *   ErrLine:      Line number in file FileName of the error, if occured.     M
  21. *                                                                            *
  22. * RETURN VALUE:                                                              M
  23. *   TrivTVStruct *: The read trivariate, or NULL if an error occured.        M
  24. *                                                                            *
  25. * KEYWORDS:                                                                  M
  26. *   TrivTVReadFromFile, files, read, trivariates                             M
  27. *****************************************************************************/
  28. TrivTVStruct *TrivTVReadFromFile(char *FileName, char **ErrStr, int *ErrLine)
  29. {
  30.     int Handler;
  31.     FILE *f;
  32.     IPTokenType Token;
  33.     char StringToken[LINE_LEN];
  34.  
  35.     if ((f = fopen(FileName, "r")) == NULL) {
  36.     *ErrStr = "File not found";
  37.     *ErrLine = 0;
  38.     return NULL;
  39.     }
  40.     Handler = IritPrsrOpenStreamFromFile(f, TRUE,
  41.                      IritPrsrSenseBinaryFile(FileName),
  42.                      FALSE);
  43.  
  44.     while ((Token = _IPGetToken(Handler, StringToken)) != IP_TOKEN_EOF &&
  45.        Token != IP_TOKEN_OPEN_PAREN);
  46.  
  47.     /* We found beginning of definition - read one: */
  48.     if (_IPGetToken(Handler, StringToken) != IP_TOKEN_TRIVAR ||
  49.     (Token = _IPGetToken(Handler, StringToken)) == IP_TOKEN_EOF) {
  50.         *ErrStr = "TRIVAR key words expected";
  51.     *ErrLine = _IPStream[Handler].LineNum;
  52.     return NULL;
  53.     }
  54.  
  55.     IritPrsrCloseStream(Handler, TRUE);
  56.  
  57.     switch (Token) {
  58.     case IP_TOKEN_BEZIER:
  59.         return TrivBzrTVReadFromFile(FileName, ErrStr, ErrLine);
  60.     case IP_TOKEN_BSPLINE:
  61.         return TrivBspTVReadFromFile(FileName, ErrStr, ErrLine);
  62.     default:
  63.         *ErrStr = "BSPLINE or BEZIER Token expected";
  64.         *ErrLine = _IPStream[Handler].LineNum;
  65.         return NULL;
  66.     }
  67. }
  68.  
  69. /*****************************************************************************
  70. * DESCRIPTION:                                                               M
  71. * Reads from a file a trivariate.                         M
  72. *   If error is found in reading the file, ErrStr is set to a string         M
  73. * describing it and ErrLine to line it occured in file relative to begining  M
  74. * of trivariate.                                 M
  75. *   If no error is detected *ErrStr is set to NULL.                 M
  76. *                                                                            *
  77. * PARAMETERS:                                                                M
  78. *   Handler:      A handler to the open stream.                     M
  79. *   ErrStr:       Will be initialized if an error has occured.               M
  80. *   ErrLine:      Line number in file FileName of the error, if occured.     M
  81. *                                                                            *
  82. * RETURN VALUE:                                                              M
  83. *   TrivTVStruct *: The read trivariate, or NULL if an error occured.        M
  84. *                                                                            *
  85. * KEYWORDS:                                                                  M
  86. *   TrivTVReadFromFile2, files, read, trivariates                            M
  87. *****************************************************************************/
  88. TrivTVStruct *TrivTVReadFromFile2(int Handler, char **ErrStr, int *ErrLine)
  89. {
  90.     char StringToken[LINE_LEN];
  91.  
  92.     switch (_IPGetToken(Handler, StringToken)) {
  93.     case IP_TOKEN_BEZIER:
  94.         return TrivBzrTVReadFromFile2(Handler, TRUE, ErrStr, ErrLine);
  95.     case IP_TOKEN_BSPLINE:
  96.         return TrivBspTVReadFromFile2(Handler, TRUE, ErrStr, ErrLine);
  97.     default:
  98.         *ErrStr = "BSPLINE or BEZIER Token expected";
  99.         *ErrLine = _IPStream[Handler].LineNum;
  100.         return NULL;
  101.     }
  102. }
  103.  
  104. /*****************************************************************************
  105. * DESCRIPTION:                                                               M
  106. * Reads from a file Bezier trivariates.                         M
  107. *   If error is detected in reading the file, ErrStr is set to a string      M
  108. * describing the error and Line to the line it occured in file.             M
  109. *   If no error is detected *ErrStr = NULL.                     M
  110. *                                                                            *
  111. * PARAMETERS:                                                                M
  112. *   FileName:     To read the trivariate from.                              M
  113. *   ErrStr:       Will be initialized if an error has occured.               M
  114. *   ErrLine:      Line number in file FileName of the error, if occured.     M
  115. *                                                                            *
  116. * RETURN VALUE:                                                              M
  117. *   TrivTVStruct *: The read trivariate, or NULL if an error occured.        M
  118. *                                                                            *
  119. * KEYWORDS:                                                                  M
  120. *   TrivBzrTVReadFromFile, files, read, trivariates                          M
  121. *****************************************************************************/
  122. TrivTVStruct *TrivBzrTVReadFromFile(char *FileName,
  123.                     char **ErrStr,
  124.                     int *ErrLine)
  125. {
  126.     int Handler;
  127.     FILE *f;
  128.     char StringToken[LINE_LEN];
  129.     TrivTVStruct *TV,
  130.     *TVTail = NULL,
  131.     *TVList = NULL;
  132.  
  133.     if ((f = fopen(FileName, "r")) == NULL) {
  134.     *ErrStr = "File not found";
  135.     *ErrLine = 0;
  136.     return NULL;
  137.     }
  138.     Handler = IritPrsrOpenStreamFromFile(f, TRUE,
  139.                      IritPrsrSenseBinaryFile(FileName),
  140.                      FALSE);
  141.  
  142.     while (_IPGetToken(Handler, StringToken) == IP_TOKEN_OPEN_PAREN) {
  143.     _IPUnGetToken(Handler, StringToken);
  144.         TV = TrivBzrTVReadFromFile2(Handler, FALSE, ErrStr, ErrLine);
  145.  
  146.     if (TVList == NULL)
  147.         TVList = TVTail = TV;
  148.     else {
  149.         TVTail -> Pnext = TV;
  150.         TVTail = TV;
  151.     }
  152.     }
  153.  
  154.     IritPrsrCloseStream(Handler, TRUE);
  155.  
  156.     return TVList;
  157. }
  158.  
  159. /*****************************************************************************
  160. * DESCRIPTION:                                                               M
  161. * Reads from a file a Bezier trivariate.                     M
  162. *   If NameWasRead is TRUE, it is assumed prefix "[TRIVAR BEZIER" has        M
  163. * already been read. This is useful for a global parser which invokes this   M
  164. * routine to read from a file several times as a parent controller.          M
  165. *   For exactly this reason, the given file descriptor is NOT closed in the  M
  166. * end.                                         M
  167. *   If error is found in reading the file, ErrStr is set to a string         M
  168. * describing it and ErrLine to line it occured in file relative to begining  M
  169. * of trivariate.                                 M
  170. *   If no error is detected *ErrStr is set to NULL.                 M
  171. *                                                                            *
  172. * PARAMETERS:                                                                M
  173. *   Handler:      A handler to the open stream.                     M
  174. *   NameWasRead:  If FALSE, also reads the TRIVAR BEZIER prefix.         M
  175. *   ErrStr:       Will be initialized if an error has occured.               M
  176. *   ErrLine:      Line number in file FileName of the error, if occured.     M
  177. *                                                                            *
  178. * RETURN VALUE:                                                              M
  179. *   TrivTVStruct *: The read trivariate, or NULL if an error occured.        M
  180. *                                                                            *
  181. * KEYWORDS:                                                                  M
  182. *   TrivBzrTVReadFromFile2, files, read, trivariates                         M
  183. *****************************************************************************/
  184. TrivTVStruct *TrivBzrTVReadFromFile2(int Handler,
  185.                      CagdBType NameWasRead,
  186.                      char **ErrStr,
  187.                      int *ErrLine)
  188. {
  189.     CagdPointType PType;
  190.     IPTokenType Token;
  191.     int i, j, ULength, VLength, WLength, MaxCoord;
  192.     char StringToken[LINE_LEN];
  193.     TrivTVStruct *NewTV;
  194.  
  195.     _IPStream[Handler].LineNum = *ErrLine;
  196.  
  197.     if (!NameWasRead) {
  198.     while ((Token = _IPGetToken(Handler, StringToken)) != IP_TOKEN_EOF &&
  199.            Token != IP_TOKEN_OPEN_PAREN);
  200.  
  201.     /* We found beginning of definition - read one: */
  202.     if (_IPGetToken(Handler, StringToken) != IP_TOKEN_TRIVAR ||
  203.         _IPGetToken(Handler, StringToken) != IP_TOKEN_BEZIER) {
  204.         *ErrStr = "TRIVAR BEZIER key words expected";
  205.         *ErrLine = _IPStream[Handler].LineNum;
  206.         return NULL;
  207.         }
  208.     }
  209.  
  210.     if ((Token = _IPGetToken(Handler, StringToken)) == IP_TOKEN_OPEN_PAREN) {
  211.     if ((*ErrStr = _IPGetSurfaceAttributes(Handler)) != NULL) {
  212.         *ErrStr = "\"[\" expected";
  213.         *ErrLine = _IPStream[Handler].LineNum;
  214.         return NULL;
  215.     }
  216.     }
  217.     else
  218.     _IPUnGetToken(Handler, StringToken);
  219.  
  220.     if ((Token = _IPGetToken(Handler, StringToken)) != IP_TOKEN_OTHER ||
  221.         sscanf(StringToken, "%d", &ULength) != 1 ||
  222.     (Token = _IPGetToken(Handler, StringToken)) != IP_TOKEN_OTHER ||
  223.     sscanf(StringToken, "%d", &VLength) != 1 ||
  224.     (Token = _IPGetToken(Handler, StringToken)) != IP_TOKEN_OTHER ||
  225.     sscanf(StringToken, "%d", &WLength) != 1) {
  226.     *ErrStr = "BEZIER Number of points expected";
  227.     *ErrLine = _IPStream[Handler].LineNum;
  228.     return NULL;
  229.     }
  230.  
  231.     Token = _IPGetToken(Handler, StringToken);
  232.     if (!IP_IS_TOKEN_POINT(Token) ||
  233.         strlen(StringToken) != 2 ||
  234.     (StringToken[0] != 'E' && StringToken[0] != 'P') ||
  235.     !isdigit(StringToken[1]) ||
  236.     atoi(&StringToken[1]) > CAGD_MAX_PT_COORD) {
  237.     *ErrStr = "BEZIER Point type expected";
  238.     *ErrLine = _IPStream[Handler].LineNum;
  239.     return NULL;
  240.     }
  241.     PType = CAGD_MAKE_PT_TYPE(StringToken[0] == 'P', atoi(&StringToken[1]));
  242.  
  243.     NewTV = TrivBzrTVNew(ULength, VLength, WLength, PType);
  244.  
  245.     /* Read the points themselves: */
  246.     MaxCoord = CAGD_NUM_OF_PT_COORD(PType);
  247.     for (i = 0; i < ULength * VLength * WLength; i++) {
  248.     if ((Token = _IPGetToken(Handler, StringToken)) != IP_TOKEN_OPEN_PAREN) {
  249.         *ErrStr = "\"[\" expected";
  250.         *ErrLine = _IPStream[Handler].LineNum;
  251.         TrivTVFree(NewTV);
  252.         return NULL;
  253.     }
  254.     if (CAGD_IS_RATIONAL_PT(PType)) {
  255.         if ((Token = _IPGetToken(Handler, StringToken)) != IP_TOKEN_OTHER ||
  256.             sscanf(StringToken, IP_FLOAT_READ,
  257.                     &NewTV -> Points[0][i]) != 1) {
  258.         *ErrStr = "Numeric data expected";
  259.         *ErrLine = _IPStream[Handler].LineNum;
  260.         TrivTVFree(NewTV);
  261.         return NULL;
  262.         }
  263.     }
  264.     for (j = 1; j <= MaxCoord; j++) {
  265.         if ((Token = _IPGetToken(Handler, StringToken)) != IP_TOKEN_OTHER ||
  266.             sscanf(StringToken, IP_FLOAT_READ,
  267.                         &NewTV -> Points[j][i]) != 1) {
  268.         *ErrStr = "Numeric data expected";
  269.         *ErrLine = _IPStream[Handler].LineNum;
  270.         TrivTVFree(NewTV);
  271.         return NULL;
  272.         }
  273.     }
  274.     if ((Token = _IPGetToken(Handler, StringToken)) != IP_TOKEN_CLOSE_PAREN) {
  275.         *ErrStr = "\"]\" expected";
  276.         *ErrLine = _IPStream[Handler].LineNum;
  277.         TrivTVFree(NewTV);
  278.         return NULL;
  279.     }
  280.     }
  281.     if ((Token = _IPGetToken(Handler, StringToken)) != IP_TOKEN_CLOSE_PAREN) {
  282.         *ErrStr = "\"]\" expected";
  283.     *ErrLine = _IPStream[Handler].LineNum;
  284.     TrivTVFree(NewTV);
  285.     return NULL;
  286.     }
  287.  
  288.     *ErrStr = NULL;
  289.     *ErrLine = _IPStream[Handler].LineNum;
  290.  
  291.     return NewTV;
  292. }
  293.  
  294. /*****************************************************************************
  295. * DESCRIPTION:                                                               M
  296. * Reads from a file Bspline trivariates.                     M
  297. *   If error is detected in reading the file, ErrStr is set to a string      M
  298. * describing the error and Line to the line it occured in file.             M
  299. *   If no error is detected *ErrStr = NULL.                     M
  300. *                                                                            *
  301. * PARAMETERS:                                                                M
  302. *   FileName:     To read the trivariate from.                              M
  303. *   ErrStr:       Will be initialized if an error has occured.               M
  304. *   ErrLine:      Line number in file FileName of the error, if occured.     M
  305. *                                                                            *
  306. * RETURN VALUE:                                                              M
  307. *   TrivTVStruct *: The read trivariate, or NULL if an error occured.        M
  308. *                                                                            *
  309. * KEYWORDS:                                                                  M
  310. *   TrivBspTVReadFromFile, files, read, trivariates                          M
  311. *****************************************************************************/
  312. TrivTVStruct *TrivBspTVReadFromFile(char *FileName,
  313.                     char **ErrStr,
  314.                     int *ErrLine)
  315. {
  316.     int Handler;
  317.     FILE *f;
  318.     char StringToken[LINE_LEN];
  319.     TrivTVStruct *TV,
  320.     *TVTail = NULL,
  321.     *TVList = NULL;
  322.  
  323.     if ((f = fopen(FileName, "r")) == NULL) {
  324.     *ErrStr = "File not found";
  325.     *ErrLine = 0;
  326.     return NULL;
  327.     }
  328.     Handler = IritPrsrOpenStreamFromFile(f, TRUE,
  329.                      IritPrsrSenseBinaryFile(FileName),
  330.                      FALSE);
  331.  
  332.     while (_IPGetToken(Handler, StringToken) == IP_TOKEN_OPEN_PAREN) {
  333.     _IPUnGetToken(Handler, StringToken);
  334.         TV = TrivBspTVReadFromFile2(Handler, FALSE, ErrStr, ErrLine);
  335.  
  336.     if (TVList == NULL)
  337.         TVList = TVTail = TV;
  338.     else {
  339.         TVTail -> Pnext = TV;
  340.         TVTail = TV;
  341.     }
  342.     }
  343.  
  344.     IritPrsrCloseStream(Handler, TRUE);
  345.  
  346.     return TVList;
  347. }
  348.  
  349. /*****************************************************************************
  350. * DESCRIPTION:                                                               M
  351. * Reads from a file a Bezier trivariate.                     M
  352. *   If NameWasRead is TRUE, it is assumed prefix "[TRIVAR BSPLINE" has       M
  353. * already been read. This is useful for a global parser which invokes this   M
  354. * routine to read from a file several times as a parent controller.          M
  355. *   For exactly this reason, the given file descriptor is NOT closed in the  M
  356. * end.                                         M
  357. *   If error is found in reading the file, ErrStr is set to a string         M
  358. * describing it and ErrLine to line it occured in file relative to begining  M
  359. * of trivariate.                                 M
  360. *   If no error is detected *ErrStr is set to NULL.                 M
  361. *                                                                            *
  362. * PARAMETERS:                                                                M
  363. *   Handler:      A handler to the open stream.                     M
  364. *   NameWasRead:  If FALSE, also reads the TRIVAR BEZIER prefix.         M
  365. *   ErrStr:       Will be initialized if an error has occured.               M
  366. *   ErrLine:      Line number in file FileName of the error, if occured.     M
  367. *                                                                            *
  368. * RETURN VALUE:                                                              M
  369. *   TrivTVStruct *: The read trivariate, or NULL if an error occured.        M
  370. *                                                                            *
  371. * KEYWORDS:                                                                  M
  372. *   TrivBzrTVReadFromFile2, files, read, trivariates                         M
  373. *****************************************************************************/
  374. TrivTVStruct *TrivBspTVReadFromFile2(int Handler,
  375.                      CagdBType NameWasRead,
  376.                      char **ErrStr,
  377.                      int *ErrLine)
  378. {
  379.     int i, j, k, Len, ULength, VLength, WLength, UOrder, VOrder, WOrder,
  380.     MaxCoord;
  381.     char StringToken[LINE_LEN];
  382.     CagdRType *KnotVector;
  383.     CagdPointType PType;
  384.     IPTokenType Token;
  385.     TrivTVStruct *NewTV;
  386.  
  387.     _IPStream[Handler].LineNum = *ErrLine;
  388.  
  389.     if (!NameWasRead) {
  390.     while ((Token = _IPGetToken(Handler, StringToken)) != IP_TOKEN_EOF &&
  391.            Token != IP_TOKEN_OPEN_PAREN);
  392.  
  393.     /* We found beginning of definition - read one: */
  394.     if (_IPGetToken(Handler, StringToken) != IP_TOKEN_TRIVAR ||
  395.         _IPGetToken(Handler, StringToken) != IP_TOKEN_BSPLINE) {
  396.         *ErrStr = "TRIVAR BSPLINE key words expected";
  397.         *ErrLine = _IPStream[Handler].LineNum;
  398.         return NULL;
  399.         }
  400.     }
  401.  
  402.     if ((Token = _IPGetToken(Handler, StringToken)) == IP_TOKEN_OPEN_PAREN) {
  403.     if ((*ErrStr = _IPGetSurfaceAttributes(Handler)) != NULL) {
  404.         *ErrStr = "\"[\" expected";
  405.         *ErrLine = _IPStream[Handler].LineNum;
  406.         return NULL;
  407.     }
  408.     }
  409.     else
  410.     _IPUnGetToken(Handler, StringToken);
  411.  
  412.     if ((Token = _IPGetToken(Handler, StringToken)) != IP_TOKEN_OTHER ||
  413.         sscanf(StringToken, "%d", &ULength) != 1 ||
  414.     (Token = _IPGetToken(Handler, StringToken)) != IP_TOKEN_OTHER ||
  415.     sscanf(StringToken, "%d", &VLength) != 1 ||
  416.     (Token = _IPGetToken(Handler, StringToken)) != IP_TOKEN_OTHER ||
  417.     sscanf(StringToken, "%d", &WLength) != 1) {
  418.     *ErrStr = "BSPLINE Number of points expected";
  419.     *ErrLine = _IPStream[Handler].LineNum;
  420.     return NULL;
  421.     }
  422.     if ((Token = _IPGetToken(Handler, StringToken)) != IP_TOKEN_OTHER ||
  423.     sscanf(StringToken, "%d", &UOrder) != 1 ||
  424.     (Token = _IPGetToken(Handler, StringToken)) != IP_TOKEN_OTHER ||
  425.     sscanf(StringToken, "%d", &VOrder) != 1 ||
  426.     (Token = _IPGetToken(Handler, StringToken)) != IP_TOKEN_OTHER ||
  427.     sscanf(StringToken, "%d", &WOrder) != 1) {
  428.     *ErrStr = "BSPLINE Order expected";
  429.     *ErrLine = _IPStream[Handler].LineNum;
  430.     return NULL;
  431.     }
  432.  
  433.     Token = _IPGetToken(Handler, StringToken);
  434.     if (!IP_IS_TOKEN_POINT(Token) ||
  435.         strlen(StringToken) != 2 ||
  436.     (StringToken[0] != 'E' && StringToken[0] != 'P') ||
  437.     !isdigit(StringToken[1]) ||
  438.     atoi(&StringToken[1]) > CAGD_MAX_PT_COORD) {
  439.     *ErrStr = "BSPLINE Point type expected";
  440.     *ErrLine = _IPStream[Handler].LineNum;
  441.     return NULL;
  442.     }
  443.     PType = CAGD_MAKE_PT_TYPE(StringToken[0] == 'P', atoi(&StringToken[1]));
  444.  
  445.     NewTV = TrivBspTVNew(ULength, VLength, WLength,
  446.              UOrder, VOrder, WOrder, PType);
  447.  
  448.     /* Read the knot vectors first: */
  449.     for (k = 0; k < 3; k++) {
  450.     switch (k) {
  451.         case 0:
  452.         KnotVector = NewTV -> UKnotVector;
  453.         Len = NewTV -> UOrder + NewTV -> ULength;
  454.         break;
  455.         case 1:
  456.         KnotVector = NewTV -> VKnotVector;
  457.         Len = NewTV -> VOrder + NewTV -> VLength;
  458.         break;
  459.         default:
  460.         case 2:
  461.         KnotVector = NewTV -> WKnotVector;
  462.         Len = NewTV -> WOrder + NewTV -> WLength;
  463.         break;
  464.     }
  465.  
  466.         if ((Token = _IPGetToken(Handler, StringToken)) != IP_TOKEN_OPEN_PAREN) {
  467.             *ErrStr = "\"[\" expected";
  468.         *ErrLine = _IPStream[Handler].LineNum;
  469.         TrivTVFree(NewTV);
  470.         return NULL;
  471.         }
  472.         if ((Token = _IPGetToken(Handler, StringToken)) != IP_TOKEN_KV) {
  473.         *ErrStr = "KV expected";
  474.         *ErrLine = _IPStream[Handler].LineNum;
  475.         TrivTVFree(NewTV);
  476.         return NULL;
  477.     }
  478.  
  479.     for (i = 0; i < Len; i++) {
  480.         if ((Token = _IPGetToken(Handler, StringToken)) != IP_TOKEN_OTHER ||
  481.             sscanf(StringToken, IP_FLOAT_READ, &KnotVector[i]) != 1) {
  482.             *ErrStr = "Numeric data expected";
  483.         *ErrLine = _IPStream[Handler].LineNum;
  484.         TrivTVFree(NewTV);
  485.         return NULL;
  486.         }
  487.     }
  488.  
  489.     if ((Token = _IPGetToken(Handler, StringToken)) != IP_TOKEN_CLOSE_PAREN) {
  490.         *ErrStr = "\"]\" expected";
  491.         *ErrLine = _IPStream[Handler].LineNum;
  492.         TrivTVFree(NewTV);
  493.         return NULL;
  494.     }
  495.     }
  496.  
  497.     /* Read the points themselves: */
  498.     MaxCoord = CAGD_NUM_OF_PT_COORD(PType);
  499.     for (i = 0; i < ULength * VLength * WLength; i++) {
  500.     if ((Token = _IPGetToken(Handler, StringToken)) != IP_TOKEN_OPEN_PAREN) {
  501.         *ErrStr = "\"[\" expected";
  502.         *ErrLine = _IPStream[Handler].LineNum;
  503.         TrivTVFree(NewTV);
  504.         return NULL;
  505.     }
  506.     if (CAGD_IS_RATIONAL_PT(PType)) {
  507.         if ((Token = _IPGetToken(Handler, StringToken)) != IP_TOKEN_OTHER ||
  508.             sscanf(StringToken, IP_FLOAT_READ,
  509.                         &NewTV -> Points[0][i]) != 1) {
  510.         *ErrStr = "Numeric data expected";
  511.         *ErrLine = _IPStream[Handler].LineNum;
  512.         TrivTVFree(NewTV);
  513.         return NULL;
  514.         }
  515.     }
  516.     for (j = 1; j <= MaxCoord; j++) {
  517.         if ((Token = _IPGetToken(Handler, StringToken)) != IP_TOKEN_OTHER ||
  518.             sscanf(StringToken, IP_FLOAT_READ,
  519.                         &NewTV -> Points[j][i]) != 1) {
  520.         *ErrStr = "Numeric data expected";
  521.         *ErrLine = _IPStream[Handler].LineNum;
  522.         TrivTVFree(NewTV);
  523.         return NULL;
  524.         }
  525.     }
  526.     if ((Token = _IPGetToken(Handler, StringToken)) != IP_TOKEN_CLOSE_PAREN) {
  527.         *ErrStr = "\"]\" expected";
  528.         *ErrLine = _IPStream[Handler].LineNum;
  529.         TrivTVFree(NewTV);
  530.         return NULL;
  531.     }
  532.     }
  533.     if ((Token = _IPGetToken(Handler, StringToken)) != IP_TOKEN_CLOSE_PAREN) {
  534.         *ErrStr = "\"]\" expected";
  535.     *ErrLine = _IPStream[Handler].LineNum;
  536.     TrivTVFree(NewTV);
  537.     return NULL;
  538.     }
  539.  
  540.     *ErrStr = NULL;
  541.     *ErrLine = _IPStream[Handler].LineNum;
  542.  
  543.     return NewTV;
  544. }
  545.